package com.xjggb.queue;

import java.util.concurrent.*;

public class Demo1Queue {
    public static void main(String[] args) throws InterruptedException {
//        生产者存储方法
//        add(E)     	// 添加数据到队列，如果队列满了，无法存储，抛出异常
//        offer(E)    // 添加数据到队列，如果队列满了，返回false
//        offer(E,timeout,unit)   // 添加数据到队列，如果队列满了，阻塞timeout时间，如果阻塞一段时间，依然没添加进入，返回false
//        put(E)      // 添加数据到队列，如果队列满了，挂起线程，等到队列中有位置，再扔数据进去，死等！

//        消费者取数据方法
//        remove()    // 从队列中移除数据，如果队列为空，抛出异常
//        poll()      // 从队列中移除数据，如果队列为空，返回null，么的数据
//        poll(timeout,unit)   // 从队列中移除数据，如果队列为空，挂起线程timeout时间，等生产者扔数据，再获取
//        take()     // 从队列中移除数据，如果队列为空，线程挂起，一直等到生产者扔数据，再获取
//

        show1();
    }




    public static void show5(){
        // 因为当前队列不存在数据，没有长度的概念。
        SynchronousQueue queue = new SynchronousQueue();

        String msg = "消息！";
    /*new Thread(() -> {
        // b = false：代表没有消费者来拿
        boolean b = false;
        try {
            b = queue.offer(msg,1, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(b);
    }).start();

    Thread.sleep(100);

    new Thread(() -> {
        System.out.println(queue.poll());
    }).start();*/
        new Thread(() -> {
            try {
                System.out.println(queue.poll(1, TimeUnit.SECONDS));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            queue.offer(msg);
        }).start();
    }

    public static void show4() throws InterruptedException {
        // 声明元素
        Task task1 = new Task("A",1000L);
        Task task2 = new Task("B",5000L);
        Task task3 = new Task("C",3000L);
        Task task4 = new Task("D",2000L);
        DelayQueue<Task> queue = new DelayQueue<Task>();

        // 将元素添加到延迟队列中
        queue.put(task1);
        queue.put(task2);
        queue.put(task3);
        queue.put(task4);

        // 消费者取数据
        // 获取元素
        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.take());
        System.out.println(queue.take());
        // A,D,C,B

    }

    public static void show3() throws InterruptedException {
        PriorityBlockingQueue queue = new PriorityBlockingQueue();

        // 生产者扔数据
        queue.add("1");
        queue.offer("2");
        queue.offer("3",2, TimeUnit.SECONDS);
        queue.put("2");

        // 消费者取数据
        System.out.println(queue.remove());
        System.out.println(queue.poll());
        System.out.println(queue.poll(2,TimeUnit.SECONDS));
        System.out.println(queue.take());

    }

    public static void show2() throws InterruptedException {
        LinkedBlockingQueue queue = new LinkedBlockingQueue();

        // 生产者扔数据
        queue.add("1");
        queue.offer("2");
        queue.offer("3",2, TimeUnit.SECONDS);
        queue.put("2");

        // 消费者取数据
        System.out.println(queue.remove());
        System.out.println(queue.poll());
        System.out.println(queue.poll(2,TimeUnit.SECONDS));
        System.out.println(queue.take());

    }

    public static void show1() throws InterruptedException {
        // 必须设置队列的长度
        ArrayBlockingQueue queue = new ArrayBlockingQueue(4);

        // 生产者扔数据
        queue.add("1");
        queue.offer("2");
        queue.offer("3",2, TimeUnit.SECONDS);
        queue.put("2");

        // 消费者取数据
        System.out.println(queue.remove());
        System.out.println(queue.poll());
        System.out.println(queue.poll(2,TimeUnit.SECONDS));
        System.out.println(queue.take());
    }


}

class Task implements Delayed {
    private String name;
    private Long age;

    public Task(String name, Long age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return 0;
    }

    @Override
    public int compareTo(Delayed o) {
        return 0;
    }
}
